package com.example.gateway.designPattern.singleton;

/**
 * @ClassName: Lhan
 * @Description:
 * @Author: YourName
 * @Date: 2024/12/30
 */

public class Lhan {

    private Lhan() {

    }
    /*
        volatile 是 Java 中的一个关键字，它用于变量声明，确保变量的内存可见性和禁止指令重排序优化。
        内存可见性意味着一个线程对 volatile 变量的修改对其他线程是立即可见的。
        这是通过在每次对 volatile 变量的读操作后和写操作前插入内存屏障来实现的，这种方式阻止了缓存的值被用来代替内存中的最新值。
        指令重排序优化是编译器和处理器为了优化程序性能而进行的一种优化手段，
        它可能会导致程序代码的执行顺序不如代码逻辑顺序。使用 volatile 可以防止这种情况发生。
     */
    private static volatile Lhan lhan;

    // 懒汉式 单例模式 （线程不安全）
    public static Lhan getInstance() {
        if (lhan == null) {
            lhan = new Lhan();
        }
        return lhan;
    }

    // 懒汉式 单例模式 （线程安全）缺点：效率低，每次获取都被阻塞
    public static synchronized Lhan getInstance1() {
        if (lhan == null) {
            lhan = new Lhan();
        }
        return lhan;
    }

    // 饿汉式 单例模式 （线程安全）  // 双重检查

    public static Lhan getInstance2() {
        if( lhan == null) {
            synchronized (Lhan.class) {
                if (lhan == null) {
                    lhan = new Lhan();
                }
            }
        }
        return lhan;
    }

    //这种事错误的写法，这种甚至都保证不了 示例的单例特性。
    public static Lhan getInstance22() {
        if( lhan == null) {
            //同时有两个线程进入 然后都执行了new Lhan()，然后返回的不是同一个实例。
            synchronized (Lhan.class) {
                lhan = new Lhan();
            }
        }
        return lhan;
    }



    /* 饿汉式 单例模式 （线程安全） 静态内部类
     * 静态内部类实现单例
    *   利用 静态内部类在 主类加载的时候静态内部类是不会加载的， 保证了懒加载的效果。避免内存浪费
    *   利用在类加载的时候 jvm会保证只有一个线程进入，从而保证了线程安全。
    *  */

    public static Lhan getInstance3() {
        return BhanHolder.lhan;
    }

    private static class BhanHolder {
        private static final Lhan lhan = new Lhan();
    }
}
